Ham Radio 2000 #1/Ham Radio 2000.iso/ham2000/packet/terminal/kam510/kam-io.pas

Pascal/Delphi Source File | 1989-12-02 | 17.7 KB | 681 lines

{ global declarations }

const
  UART_THR = $00;    { offset from base of UART Registers for IBM PC }
  UART_RBR = $00;
  UART_IER = $01;
  UART_IIR = $02;
  UART_LCR = $03;
  UART_MCR = $04;
  UART_LSR = $05;
  UART_MSR = $06;

  I8088_IMR = $21;   { port address of the Interrupt Mask Register }

  COM1_Base = $03F8;  { port addresses for the UART }
  COM2_Base = $02F8;

  COM1_Irq = 4;  { Interrupt line for the UART }
  COM2_Irq = 3;

  Async_Buffer_Max = $0FFF;

var

  OldInterruptSegment,
  OldInterruptOffset : integer;

  Async_Buffer       : Array[0..Async_Buffer_Max] of char;
  Async_Open_Flag    : Boolean;   { true if Open but no Close }
  Async_Port         : Integer;   { current Open port number (1 or 2) }
  Async_Base         : Integer;   { base for current open port }
  Async_Irq          : Integer;   { irq for current open port }

  Async_Buffer_Overflow : Boolean;  { True if buffer overflow has happened }
  Async_MaxBufferUsed   : Integer;

    { Async_Buffer is empty if Head = Tail }
  Async_Buffer_Head  : Integer;   { Locn in Async_Buffer to put next char }
  Async_Buffer_Tail  : Integer;   { Locn in Async_Buffer to get next char }
  Async_Buffer_NewTail : Integer;

const
  Async_Num_Bauds = 8;
  Async_Baud_Table : array [1..Async_Num_Bauds] of record
                                                     Baud, Bits : integer
                                                   end
                   = ((Baud:110;  Bits:$00),
                      (Baud:150;  Bits:$20),
                      (Baud:300;  Bits:$40),
                      (Baud:600;  Bits:$60),
                      (Baud:1200; Bits:$80),
                      (Baud:2400; Bits:$A0),
                      (Baud:4800; Bits:$C0),
                      (Baud:9600; Bits:$E0));

{----------------------------------------------------------------------}
{ Issue Interrupt $14 to initialize the UART                           }
{ See the IBM PC Technical Reference Manual for the format of ComParm  }
{----------------------------------------------------------------------}

procedure BIOS_RS232_Init(ComPort, ComParm : Integer);
var
  Regs : Registers;
begin
  with Regs do
    begin
      ax := ComParm AND $00FF;  { AH=0; AL=ComParm }
      dx := ComPort;
      Intr($14, Regs)
    end
end; { BIOS_RS232_Init }

{----------------------------------------------------------------------}
{ call DOS to set an interrupt vector                                  }
{----------------------------------------------------------------------}
procedure GetInterruptVector(v : integer);
var Regs : Registers;
begin
  with Regs do
    begin
      ax := $3500 + (v AND $00FF);
      MsDos(Regs);
      OldInterruptSegment := bx;
      OldInterruptOffset  := es;
    end;
end;

procedure DOS_Set_Intrpt(v, s, o : integer);
var
  Regs : Registers;
begin
  with Regs do
    begin
      ax := $2500 + (v AND $00FF);
      ds := s;
      dx := o;
      MsDos(Regs)
    end
end; { DOS_Set_Intrpt }

procedure RestoreInterruptVector(v : integer);
begin
  DOS_Set_Intrpt(v, OldInterruptSegment, OldInterruptOffset);
end;

{----------------------------------------------------------------------}
{                                                                      }
{  ASYNCISR.INC - Interrupt Service Routine                            }
{ Invoked when the UART has received a byte of data from the           }
{  communication line                                                  }
{                                                                      }
{----------------------------------------------------------------------}

procedure Async_Isr;
interrupt;
begin

  Inline(
    $FB/                           { STI }
      { get the incoming character }
      { Async_Buffer[Async_Buffer_Head] := Chr(Port[UART_RBR + Async_Base]); }
    $8B/$16/Async_Base/            { MOV DX,Async_Base }
    $EC/                           { IN AL,DX }
    $8B/$1E/Async_Buffer_Head/     { MOV BX,Async_Buffer_Head }
    $88/$87/Async_Buffer/          { MOV Async_Buffer[BX],AL }
      { Async_Buffer_NewHead := Async_Buffer_Head + 1; }
    $43/                           { INC BX }
      { if Async_Buffer_NewHead > Async_Buffer_Max then
          Async_Buffer_NewHead := 0; }
    $81/$FB/Async_Buffer_Max/      { CMP BX,Async_Buffer_Max }
    $7E/$02/                       { JLE L001 }
    $33/$DB/                       { XOR BX,BX }
      { if Async_Buffer_NewHead = Async_Buffer_Tail then
          Async_Buffer_Overflow := TRUE
        else }
{L001:}
    $3B/$1E/Async_Buffer_Tail/     { CMP BX,Async_Buffer_Tail }
    $75/$08/                       { JNE L002 }
    $C6/$06/Async_Buffer_Overflow/$01/ { MOV Async_Buffer_Overflow,1 }
    $90/                           { NOP }
    $EB/$04/                       { JMP SHORT L003 }
      { Async_Buffer_Head := Async_Buffer_NewHead }
{L002:}
    $89/$1E/Async_Buffer_Head/     { MOV Async_Buffer_Head,BX }
{L003:}
      { disable interrupts }
    $FA/                           { CLI }
      { Port[$20] := $20; }  { use non-specific EOI }
    $B0/$20/                       { MOV AL,20h }
    $E6/$20 )                      { OUT 20h,AL }
end; { Async_Isr }
{----------------------------------------------------------------------}
{ Async_Close                                                          }
{ Turn off the COM port interrupts.                                    }
{ reset the interrupt system when UART interrupts no longer needed     }
{----------------------------------------------------------------------}

procedure Async_Close;
var
  i, m : Integer;
begin
  if Async_Open_Flag then          { disable the IRQ on the 8259 }
    begin
      Inline($FA);                 { disable interrupts }
      i := Port[I8088_IMR];        { get the interrupt mask register }
      m := 1 shl Async_Irq;        { set mask to turn off interrupt }
      Port[I8088_IMR] := i OR m;
                                   { disable the 8250 data ready interrupt }
      Port[UART_IER + Async_Base] := 0;
                                   { disable OUT2 on the 8250 }
      Port[UART_MCR + Async_Base] := 0;
      RestoreInterruptVector(Async_Irq + 8);
      Inline($FB);                 { enable interrupts }
                                   { restore old interrupt vector }
      Async_Open_Flag := FALSE     { so we know the port is closed }
    end
end; { Async_Close }


{----------------------------------------------------------------------}
{      Async_Open(Port, Baud : Integer;                                }
{               Parity : Char;                                         }
{               WordSize, StpBits : Integer) : Boolean                 }
{      Sets up interrupt vector, initialies the COM port for           }
{      processing, sets pointers to the buffer.  Returns FALSE if COM  }
{      port not installed.                                             }
{----------------------------------------------------------------------}

function Async_Open(ComPort       : Integer;
                    BaudRate      : Integer;
                    Parity        : Char;
                    WordSize      : Integer;
                    StopBits      : Integer): boolean;
var
  ComParm : Integer;
  i, m : Integer;
begin
  Async_Open_Flag := FALSE;
  if Async_Open_Flag then Async_Close;

  if ComPort = 2 then
    begin
      Async_Port := 2;
      Async_Base := COM2_Base;
      Async_Irq  := COM2_Irq
    end
  else
    begin
      Async_Port := 1;  { default to COM1 }
      Async_Base := COM1_Base;
      Async_Irq  := COM1_Irq
    end;

  GetInterruptVector(Async_Irq + 8);

  if (Port[UART_IIR + Async_Base] AND $00F8) <> 0
  then
    Async_Open := FALSE
  else
    begin

      Async_Buffer_Head := 0;
      Async_Buffer_Tail := 0;
      Async_Buffer_Overflow := FALSE;

  { Build the ComParm for RS232_Init }
  { See Technical Reference Manual for description }

      ComParm := $0000;

  { Set up the bits for the baud rate }
      i := 0;
      repeat
        i := i + 1
      until (Async_Baud_Table[i].Baud = BaudRate) OR (i = Async_Num_Bauds);
      ComParm := ComParm OR Async_Baud_Table[i].Bits;

      if Parity in ['E', 'e'] then ComParm := ComParm OR $0018
      else if Parity in ['O', 'o'] then ComParm := ComParm OR $0008
      else ComParm := ComParm OR $0000;  { default to No parity }

      if WordSize = 7
        then ComParm := ComParm OR $0002
        else ComParm := ComParm OR $0003;  { default to 8 data bits }

      if StopBits = 2
        then ComParm := ComParm OR $0004
        else ComParm := ComParm OR $0000;  { default to 1 stop bit }

  { use the BIOS COM port initialization routine to save typing the code }
      BIOS_RS232_Init(Async_Port - 1, ComParm);

      DOS_Set_Intrpt(Async_Irq + 8, CSeg, Ofs(Async_Isr));

  { read the RBR and reset any possible pending error conditions }
  { first turn off the Divisor Access Latch Bit to allow access to RBR, etc. }

      Inline($FA);  { disable interrupts }

      Port[UART_LCR + Async_Base] := Port[UART_LCR + Async_Base] AND $7F;
  { read the Line Status Register to reset any errors it indicates }
      i := Port[UART_LSR + Async_Base];
  { read the Receiver Buffer Register in case it contains a character }
      i := Port[UART_RBR + Async_Base];

  { enable the irq on the 8259 controller }
      i := Port[I8088_IMR];  { get the interrupt mask register }
      m := (1 shl Async_Irq) XOR $00FF;
      Port[I8088_IMR] := i AND m;

  { enable the data ready interrupt on the 8250 }
      Port[UART_IER + Async_Base] := $01; { enable data ready interrupt }

  { enable OUT2 on 8250 }
      i := Port[UART_MCR + Async_Base];
      Port[UART_MCR + Async_Base] := i OR $08;

      Inline($FB); { enable interrupts }
      Async_Open_Flag := TRUE;  { bug fix by Scott Herr }
      Async_Open := TRUE;
  end;
end; { Async_Open }

{----------------------------------------------------------------------}
{      Transmits the character.                                        }
{----------------------------------------------------------------------}

procedure kam_out(C : char);
var
  i, m, counter : Integer;
begin
  { turn on OUT2, DTR, and RTS }
    Port[UART_MCR + Async_Base] := $0B;  { wait for CTS }
    while ((Port[UART_MSR + Async_Base] AND $10) = 0)  do ;
 { wait for Transmit Hold Register Empty (THRE) }
    while ((Port[UART_LSR + Async_Base] AND $20) = 0) do ;
 { send the character }
    Inline($FA); { disable interrupts }
    Port[UART_THR + Async_Base] := Ord(C);
    Inline($FB) { enable interrupts }
end;

{----------------------------------------------------------------------}
{      Remove Character From Interrupt Driven Buffer                   }
{----------------------------------------------------------------------}

function kam_in: char;
begin
  Inline($FA);                           { disable interrupts }
  kam_in := Async_Buffer[Async_Buffer_Tail];
  Async_Buffer_Tail := (Async_Buffer_Tail + 1) AND Async_Buffer_Max;
  Inline($FB);                           { enable interrupts }
end;

{----------------------------------------------------------------------}
{      If a character is available, returns TRUE                       }
{----------------------------------------------------------------------}

function char_ready:boolean;
begin
  char_ready := (Async_Buffer_Head <> Async_Buffer_Tail);
end;

var _bufchr : char;

procedure clear_buffer;
begin
  repeat
    while (char_ready) do
    begin
      _bufchr := kam_in;
      delay(2);
    end;
    delay(50);
  until NOT char_ready;
end;

procedure Cmd(s : msg_type);
var i : integer;
begin
  for i := 1 to length(s) do
    kam_out(s[i]);
end;

procedure CmdCR(s : msg_type);
begin
  Cmd(s);
  if (s = ^C) then delay(200);
  Cmd(#13);
end;

procedure CmdClr(s : msg_type);
begin
  Cmd(s);
  clear_buffer;
end;

procedure CmdCRClr(s : msg_type);
begin
  CmdCR(s);
  clear_buffer;
end;

procedure wait_for_colon;
begin
  _bufchr := ' ';
  repeat
    if (char_ready) then
      _bufchr := kam_in;
  until (_bufchr = ':');
end;

procedure CmdColon(s : msg_type);
begin
  clear_buffer;
  Cmd(s);
  wait_for_colon;
end;

procedure ForceCmd;
begin
  if (mode = PACKET) then
  begin
    cmd(^C);
    delay(200);
  end
  else
    CmdColon(^C'X');
end;

procedure CmdCRColon(s : msg_type);
begin
  CmdColon(s + #13);
end;

procedure xmt_mode;
begin
  if mode in [CW,RTTY,ASCII,AMTOR] then
  begin
    xmt_ON := TRUE;
    CmdClr(^C'T');
    case mode of
      CW : ;
      RTTY, ASCII : if xmt_on_delay > 0 then
                      delay(xmt_on_delay * 100);
    end;
  end;
end;

procedure cw_status;
var  status_str : string[7];
     i : integer;
begin
  Cmd(^C'R');
  status_str := '        ';
  repeat
    for i := 1 to 6 do
      status_str[i] := status_str[i + 1];
    repeat until char_ready;
    status_str[7] := kam_in;
  until (status_str[1] = '-');
  if (status_str[7] = '-') then
    rcv_wpm := copy(status_str,5,2);
end;

procedure rcv_stat;
begin
  if mode in [CW,RTTY,ASCII,AMTOR] then
  begin
    case mode of
      ASCII,
      RTTY,
      AMTOR : CmdClr(^C'R');
      CW    : cw_status;
    end;
  end;
end;

procedure rcv_mode;
begin
  if mode in [CW,RTTY,ASCII,AMTOR] then
  begin
    xmt_ON := FALSE;
    rcv_stat;
  end;
end;

procedure mod_rtty_invert;
begin
  CmdClr(^C'R');
  CmdClr(^C'I');
  invert := NOT invert;
  if xmt_ON then xmt_mode;
end;

procedure set_rtty_shift;
begin
  CmdClr(^C'R');
  CmdClr(^C'S');
  if xmt_on then xmt_mode;
end;

procedure cw_mode;
begin
  ForceCmd;
  mode := CW;
  CmdCRColon('E OFF');
  CmdCRColon('XM ON');
  CmdCRClr('CW ' + xmt_wpm);
  cw_status;
  state := receive;
end;

procedure kam_xmt_wpm;
begin
  cw_mode;
  if xmt_ON then
    CmdClr(^C'T');
end;

procedure set_rtty_baud;
begin
  ForceCmd;
  CmdCRColon('RB ' + baud_rate[baud]);
  CmdCRClr('R');
  state := receive;
end;

procedure rtty_mode;
begin
  ForceCmd;
  mode := RTTY;
  baud := 0;
  CmdCRColon('E OFF');
  CmdCRColon('XM ON');
  CmdCRColon('MARK 2125');
  CmdCRColon('SPACE 2295');
  CmdCRColon('INVERT OFF');
  CmdCRColon('CRAdd ON');
  CmdCRColon('LF ON');
  CmdCRColon('DIDdle ON');
  CmdCRColon('SH ' + rtty_shift[shift]);
  CmdCRColon('RB ' + baud_rate[baud]);
  CmdCRClr('R');
  state := receive;
end;

procedure ascii_mode;
begin
  ForceCmd;
  mode := ASCII;
  baud := 5;
  CmdCRColon('E OFF');
  CmdCRColon('XM ON');
  CmdCRColon('MARK 2125');
  CmdCRColon('SPACE 2295');
  CmdCRColon('ASCB ' + baud_rate[baud] );
  shift := 0;
  CmdCRColon('SH ' + rtty_shift[shift]);
  CmdCRColon('INVERT OFF');
  CmdCRColon('CRAdd ON');
  CmdCRColon('LF ON');
  CmdCRClr('A');
  state := receive;
end;

procedure packet_mode;
begin
  ForceCmd;
  mode := PACKET;
  CmdCRColon('E ON');
  CmdCRColon('XM OFF');
  CmdCRColon('MARK '+packet_mark);
  CmdCRColon('SPACE '+packet_space);
  shift := 0;
  CmdCRColon('SH '+ rtty_shift[shift]);
  CmdCRColon(SW_VHF+'A');
  CmdCR('');
  band := VHF;
  state := transceive;
end;

procedure HF_Packet;
begin
  ForceCmd;
  CmdCRColon(SW_HF+'A');
  CmdCR('');
  band := HF;
end;

procedure VHF_Packet;
begin
  ForceCmd;
  CmdCRColon(SW_VHF+'A');
  CmdCR('');
  band := VHF;
end;

procedure AmtorAB(S: string);
begin
  ForceCmd;
  mode := AMTOR;
  CmdCRColon('E OFF');
  CmdCRColon('XM ON');
  if S = '' then begin
                   CmdCRClr('AM');
                   AmtorMode := AB;
                   state := receive;
                 end
            else begin
                   CmdCRClr('AM '+SELCALL);
                   state := transmit;
                   AmtorMode := CALL;
                 end;
  band := HF;
end;

procedure AmtorListen;
begin
  ForceCmd;
  mode := AMTOR;
  CmdCRColon('E OFF');
  CmdCRColon('XM ON');
  shift := 0;
  CmdCRColon('SH '+rtty_shift[shift]);
  CmdCRClr('L');
  AmtorMode := L;
  state := receive;
  band := HF;
end;

procedure AmtorFEC;
begin
  ForceCmd;
  mode := AMTOR;
  CmdCRColon('E OFF');
  CmdCRColon('XM ON');
  CmdCRClr('FEC');
  AmtorMode := FEC;
  state := receive;
  band := HF;
 end;

procedure packet_connect;
begin
  ForceCmd;
  CmdCR('C ' + PKCall);
end;

procedure packet_disconnect;
begin
  ForceCmd;
  CmdCR('D');
end;

procedure PacketID;
begin
  ForceCmd;
  delay(200);
  CmdCRColon('I');
end;

procedure new_mode;
begin
  save_screen;
  aux_color;
  window(35,8,45,16);
  clrscr;
  writeln;
  writeln(' 1> AMTOR');
  writeln(' 2> ASCII');
  writeln(' 3> CW');
  writeln(' 4> PACKET');
  writeln(' 5> RTTY');
  writeln;
  write  (' select..');
  repeat key := readkey until key in ['1'..'5'];
  write(key);
  window(1,1,80,25);
  restore_screen;
  if (mode = PACKET) then packet_disconnect;
  case key of
    '1' : AmtorListen;
    '2' : ascii_mode;
    '3' : cw_mode;
    '4' : packet_mode;
    '5' : rtty_mode;
  end;
end;

procedure init_interface;
begin
  if (Async_Open(xmt_port, kam_baud_rate, 'N', 8, 1) = FALSE) then
  begin
    restore_entry_screen;
    Writeln('COM',xmt_port:1,' not installed.');
    halt;
  end;
  writeln('Initializing KAM interface');
  mode := PACKET;
  CmdCRColon('XOFF 0');
  CmdCRColon('XON 0');
  packet_mode;
end;

procedure reset_kam;
begin
  case mode of
    CW, RTTY, ASCII, AMTOR : CmdColon(^C'X');
    PACKET : begin
               CmdCRColon('MARK 2100');
               CmdCRColon('SPACE 2300');
               CmdCRColon('8BITCONV ON');
               CmdCRClr(SW_VHF+'A');
               CmdCR('');
             end;
  end;
  Async_close;
end;